home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2001 December / pcwk12201b.iso / Wersje pelne i specjalne / Winamp 2.77 i 3.0beta / wasabi-sdk_beta1.exe / studio / common / region.cpp < prev    next >
C/C++ Source or Header  |  2001-10-08  |  11KB  |  385 lines
  1. /*
  2.  
  3.   Nullsoft WASABI Source File License
  4.  
  5.   Copyright 1999-2001 Nullsoft, Inc.
  6.  
  7.     This software is provided 'as-is', without any express or implied
  8.     warranty.  In no event will the authors be held liable for any damages
  9.     arising from the use of this software.
  10.  
  11.     Permission is granted to anyone to use this software for any purpose,
  12.     including commercial applications, and to alter it and redistribute it
  13.     freely, subject to the following restrictions:
  14.  
  15.     1. The origin of this software must not be misrepresented; you must not
  16.        claim that you wrote the original software. If you use this software
  17.        in a product, an acknowledgment in the product documentation would be
  18.        appreciated but is not required.
  19.     2. Altered source versions must be plainly marked as such, and must not be
  20.        misrepresented as being the original software.
  21.     3. This notice may not be removed or altered from any source distribution.
  22.  
  23.  
  24.   Brennan Underwood
  25.   brennan@nullsoft.com
  26.  
  27. */
  28.  
  29. #include <windows.h>
  30. #include "region.h"
  31.  
  32. #include "canvas.h"
  33. #include "basewnd.h"
  34.  
  35. Region::Region() {
  36.     hrgn = CreateRectRgn(0,0,0,0);
  37. }
  38.  
  39. Region::Region(RECT *r) {
  40.     hrgn = CreateRectRgn(r->left,r->top,r->right,r->bottom);
  41. }
  42.  
  43. Region::Region(int l, int t, int r, int b) {
  44.     hrgn = CreateRectRgn(l,t,r,b);
  45. }
  46.  
  47. Region::Region(HRGN r) {
  48.   HRGN R = CreateRectRgn(0, 0, 0,0);
  49.   CombineRgn(R, r, r, RGN_COPY);
  50.   hrgn = R;
  51. }
  52.  
  53. Region::Region(Canvas *c) {
  54.     hrgn = CreateRectRgn(0,0,0,0);
  55.     GetClipRgn(c->getHDC(), hrgn);
  56. }
  57.  
  58. Region::~Region() {
  59.     if (hrgn)
  60.         DeleteObject(hrgn);
  61. } 
  62.  
  63. Region *Region::clone() {
  64.   Region *newregion = new Region(getHRGN());
  65.   return newregion;
  66. }
  67.  
  68. void Region::disposeClone(Region *r) {
  69.   delete r; // todo: validate pointer before deleting
  70. }
  71.  
  72. // returns a handle that SetWindowRgn understands (non portable). We should NOT delete this handle, windows will delete 
  73. // it by itself upon setting a new region of destroying the window
  74. HRGN Region::makeWindowRegion() {
  75.   HRGN R = CreateRectRgn(0, 0, 0,0);
  76.   CombineRgn(R, hrgn, hrgn, RGN_COPY);
  77.   return R;
  78. }
  79.  
  80. Region::Region(SkinBitmap *bitmap, int xoffset, int yoffset, BOOL inverted, int dothreshold, char threshold, int thinverse) {
  81.   hrgn = alphaToRegionRect(bitmap, xoffset, yoffset, FALSE, 0, 0, 0, 0, inverted, dothreshold, threshold, thinverse);
  82. }
  83.  
  84. Region::Region(SkinBitmap *bitmap, int xoffset, int yoffset, int _x, int _y, int _w, int _h, BOOL inverted, int dothreshold, char threshold, int thinverse) {
  85.   hrgn = alphaToRegionRect(bitmap, xoffset, yoffset, TRUE, _x, _y, _w, _h, inverted, dothreshold, threshold, thinverse);
  86. }
  87.  
  88. HRGN Region::alphaToRegionRect(SkinBitmap *bitmap, int xoffset, int yoffset, BOOL portion, int _x, int _y, int _w, int _h, BOOL inverted, int dothreshold, unsigned char threshold, int thinverse) {
  89.  
  90.     HRGN hRgn = NULL;
  91.   int bmWidth=bitmap->getWidth();
  92.   int bmHeight=bitmap->getHeight();
  93.   int fullw=bitmap->getFullWidth();
  94.  
  95.   void *pbits32=bitmap->getBits();
  96.   if (!pbits32) return NULL;
  97.  
  98.     RGNDATA *pData;
  99.     int y, x;
  100.  
  101.     // For better performances, we will use the ExtCreateRegion() function to create the
  102.     // region. This function take a RGNDATA structure on entry. We will add rectangles by
  103.     // amount of ALLOC_UNIT number in this structure.
  104.   // JF> rects are 8 bytes, so this allocates just under 16kb of memory, no need to REALLOC
  105.     #define MAXRECTS 2000
  106.     pData = (RGNDATA *)MALLOC(sizeof(RGNDATAHEADER) + (sizeof(RECT) * MAXRECTS));
  107.   if (!pData) return NULL;
  108.  
  109.     pData->rdh.dwSize = sizeof(RGNDATAHEADER);
  110.     pData->rdh.iType = RDH_RECTANGLES;
  111.     pData->rdh.nCount = pData->rdh.nRgnSize = 0;
  112.  
  113.   SetRect(&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
  114.  
  115.   int x_end=(portion ? _w+_x-bitmap->getX() : bmWidth);
  116.   int y_end=(portion ? _h+_y-bitmap->getY() : bmHeight);
  117.   int x_start=(portion ? _x-bitmap->getX() : 0);
  118.   int y_start=(portion ? _y-bitmap->getY() : 0);
  119.  
  120.   unsigned int iv=inverted?0xff000000:0;
  121.  
  122.   int xo=bitmap->getX();
  123.   int yo=bitmap->getY();
  124.     for (y = y_start; y < y_end; y++) {
  125.         // Scan each bitmap pixel from left to right
  126.     unsigned int *lineptr=((unsigned int *)pbits32) + fullw*(y+yo) + xo;
  127.         for (x = x_start; x < x_end; x++) {
  128.             // Search for a continuous range of "non transparent pixels"
  129.             int x0 = x;
  130.         unsigned int *p = lineptr;
  131.       if (dothreshold) {
  132.         if (thinverse) {
  133.                   while (x < x_end) {
  134.             unsigned int a=p[x];
  135.                       if ((a&0xff000000) == iv || 
  136.                 (((((a & 0xFF) > threshold || ((a & 0xFF00) >> 8) > threshold || ((a & 0xFF0000) >> 16) > threshold)))))
  137.                                   break;
  138.                       x++;
  139.                   }
  140.         }
  141.         else {
  142.                   while (x < x_end) {
  143.             unsigned int a=p[x];
  144.                       if ((a&0xff000000) == iv || 
  145.                 (((((a & 0xFF) < threshold || ((a & 0xFF00) >> 8) < threshold || ((a & 0xFF0000) >> 16) < threshold)))))
  146.                                   break;
  147.                       x++;
  148.                   }
  149.         }
  150.       }
  151.       else {
  152.               while (x < x_end) {
  153.                   if ((p[x] & 0xFF000000) == iv) break;
  154.           x++;
  155.         }
  156.       }
  157.  
  158.             if (x > x0) {
  159.                 SetRect(((RECT *)&pData->Buffer) + pData->rdh.nCount, x0, y, x, y+1);
  160.  
  161.         pData->rdh.nCount++;
  162.  
  163.                 if (x0 < pData->rdh.rcBound.left) pData->rdh.rcBound.left = x0;
  164.                 if (y < pData->rdh.rcBound.top) pData->rdh.rcBound.top = y;
  165.                 if (x > pData->rdh.rcBound.right) pData->rdh.rcBound.right = x;
  166.                 if (y >= pData->rdh.rcBound.bottom) pData->rdh.rcBound.bottom = y+1;
  167.  
  168.                 // On Windows98, ExtCreateRegion() may fail if the number of rectangles is too
  169.                 // large (ie: > 4000). Therefore, we have to create the region by multiple steps.
  170.                 if (pData->rdh.nCount == MAXRECTS) {
  171.                     HRGN h = ExtCreateRegion(NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * pData->rdh.nCount), pData);
  172.                     if (hRgn) {
  173.                         CombineRgn(hRgn, hRgn, h, RGN_OR);
  174.                         DeleteObject(h);
  175.                     }
  176.                     else hRgn = h;
  177.                     pData->rdh.nCount = 0;
  178.                     SetRect(&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
  179.                 }
  180.             }
  181.         }
  182.     }
  183.  
  184.     // Create or extend the region with the remaining rectangles
  185.     HRGN h = ExtCreateRegion(NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * pData->rdh.nCount), pData);
  186.     if (hRgn)
  187.     {
  188.         CombineRgn(hRgn, hRgn, h, RGN_OR);
  189.         DeleteObject(h);
  190.     }
  191.     else
  192.         hRgn = h;
  193.  
  194.     // Clean up
  195.     FREE(pData);
  196.  
  197.   if (hRgn && (xoffset || yoffset))
  198.     OffsetRgn(hRgn, xoffset, yoffset);
  199.  
  200.  
  201.     return hRgn;
  202. }
  203.  
  204. BOOL Region::ptInRegion(POINT *pt) {
  205.   ASSERT(hrgn != NULL);
  206.   return PtInRegion(hrgn, pt->x, pt->y);
  207. }
  208.  
  209. void Region::offset(int x, int y) {
  210.   ASSERT(hrgn != NULL);
  211.   OffsetRgn(hrgn, x, y);
  212. }
  213.  
  214. void Region::getBox(RECT *r) {
  215.   GetRgnBox(hrgn, r);
  216. }
  217.  
  218. HRGN Region::getHRGN() {
  219.   return hrgn;
  220. }
  221.  
  222. void Region::subtract(RECT *r) {
  223.   Region *s = new Region(r);
  224.   subtract(s);
  225.   delete s;
  226. }
  227.  
  228. void Region::subtract(Region *reg) {
  229.   CombineRgn(hrgn, hrgn, reg->getHRGN(), RGN_DIFF);
  230. }
  231.  
  232. void Region::and(Region *reg) {
  233.   CombineRgn(hrgn, hrgn, reg->getHRGN(), RGN_AND);
  234. }
  235.  
  236. void Region::addRect(RECT *r) {
  237.   Region *a = new Region(r);
  238.   add(a);
  239.   delete a;
  240. }
  241.  
  242. void Region::add(Region *reg) {
  243.   ASSERT(reg != NULL);
  244.   CombineRgn(hrgn, hrgn, reg->getHRGN(), RGN_OR);
  245. }
  246.  
  247. int Region::isEmpty() {
  248.   RECT r;
  249.   getBox(&r);
  250.   if (r.left == r.right && r.bottom == r.top) return 1;
  251.   return 0;
  252. }
  253.  
  254. int Region::enclosed(Region *r) {
  255.   HRGN h = CreateRectRgn(0,0,0,0);
  256.   int rs = CombineRgn(h, hrgn, r->getHRGN(), RGN_DIFF);
  257.   DeleteObject(h);
  258.   return rs == NULLREGION;
  259. }
  260.  
  261. int Region::enclosed(Region *r, Region *outside) {
  262.   int rs = CombineRgn(outside->getHRGN(), hrgn, r->getHRGN(), RGN_DIFF);
  263.   return rs == NULLREGION;
  264. }
  265.  
  266. #define IntersectRgn(hrgnResult, hrgnA, hrgnB) CombineRgn(hrgnResult, hrgnA, hrgnB, RGN_AND)
  267.  
  268. int Region::intersects(Region *r) {
  269.   ASSERT(r != NULL);
  270.   HRGN res = CreateRectRgn(0,0,0,0);
  271.   int rs = IntersectRgn(res, hrgn, r->getHRGN());
  272.   DeleteObject(res);
  273.   return (rs != NULLREGION && rs != ERROR);
  274. }
  275.  
  276. int Region::intersects(Region *r, Region *intersection) {
  277.   ASSERT(r != NULL);
  278.   ASSERT(intersection != NULL);
  279.   int rs = IntersectRgn(intersection->getHRGN(), hrgn, r->getHRGN());
  280.   return (rs != NULLREGION && rs != ERROR);
  281. }
  282.  
  283. int Region::intersects(RECT *r) {
  284.   return RectInRegion(hrgn, r);
  285. }
  286.  
  287. int Region::intersects(RECT *r, Region *intersection) {
  288.   Region *rect = new Region(r);
  289.   int res = intersects(rect, intersection);
  290.   delete rect;
  291.   return res;
  292. }
  293.  
  294. void Region::getRgnBox(RECT *r) {
  295.   ASSERT(r != NULL);
  296.   GetRgnBox(hrgn, r);
  297. }
  298.  
  299. void Region::empty() {
  300.   ASSERT(hrgn != NULL);
  301.   DeleteObject(hrgn);
  302.   hrgn = CreateRectRgn(0,0,0,0);
  303.   ASSERT(hrgn != NULL);
  304. }
  305.  
  306. void Region::setRect(RECT *r) {
  307.   ASSERT(hrgn != NULL);
  308.   SetRectRgn(hrgn, r->left, r->top, r->right, r->bottom);
  309. }
  310.  
  311. int Region::equals(Region *r) {
  312.   ASSERT(r);
  313.   Region *cl = r->clone();
  314.   cl->subtract(this);
  315.   int ret = cl->isEmpty();
  316.   r->disposeClone(cl);
  317.   cl = clone();
  318.   cl->subtract(r);
  319.   ret &= cl->isEmpty();
  320.   disposeClone(cl);
  321.   return ret;
  322. }
  323.  
  324. int Region::isRect() {
  325.   RECT r;
  326.   getBox(&r);
  327.   Region *n = new Region(&r);
  328.   ASSERT(n != NULL);
  329.   if (equals(n)) {
  330.     delete n;
  331.     return 1;
  332.   }
  333.   delete n;
  334.   return 0;
  335. }
  336.  
  337. void Region::scale(double s, BOOL round) {
  338.   scale(s, s, round);
  339. }
  340.  
  341. void Region::scale(double sx, double sy, BOOL round) {
  342.   ASSERT(hrgn != NULL);
  343.   DWORD size=0;
  344.   size = GetRegionData(hrgn, size, NULL); 
  345.   if (!size) return;
  346.   DWORD res;
  347.   RGNDATA *data = (RGNDATA *)MALLOC(size);
  348.   RECT *r = (RECT *)data->Buffer;
  349.  
  350.   res = GetRegionData(hrgn, size, (RGNDATA *)data);
  351.   double adj = round?0.99999:0.0;
  352.   int iadj = round?1:0;
  353.  
  354.   if (data->rdh.nCount == 1) {
  355.     RECT nr = data->rdh.rcBound;
  356.     nr.left = (int)((double)(nr.left-iadj) * sx);
  357.     nr.top = (int)((double)(nr.top-iadj) * sy);
  358.     nr.right = (int)((double)nr.right * sx + adj);
  359.     nr.bottom = (int)((double)nr.bottom * sy + adj);
  360.     setRect(&nr);
  361.     FREE(data);
  362.     return;
  363.   }
  364.  
  365.   for (int i=0;i<(int)data->rdh.nCount;i++) {
  366.     r[i].left = (int)((double)(r[i].left-iadj) * sx);
  367.     r[i].top = (int)((double)(r[i].top-iadj) * sy);
  368.     r[i].right = (int)((double)r[i].right * sx + adj);
  369.     r[i].bottom = (int)((double)r[i].bottom * sy + adj);
  370.   }
  371.  
  372.   HRGN nhrgn = ExtCreateRegion(NULL, size, data);
  373.   ASSERTPR(nhrgn != NULL, StringPrintf("size : %s", size));
  374.   FREE(data);
  375.   DeleteObject(hrgn);
  376.   hrgn = nhrgn;
  377. }
  378.  
  379. void Region::debug() {
  380.   HDC d = GetDC(NULL);
  381.   InvertRgn(d, getHRGN());
  382.   Sleep(1000);
  383.   InvertRgn(d, getHRGN());
  384. }
  385.